namespace ext.data
{
	using System;
	using System.Runtime.CompilerServices;
	using System.Html;
	using System.Collections;
	
	
	/// <summary>
	/// Abstract base class for implementations which provide retrieval of unformatted data objects.
	/// This class is intended to be extended and should not be created directly. For existing implementations,
	/// see {@link Ext.data.DirectProxy}, {@link Ext.data.HttpProxy}, {@link Ext.data.ScriptTagProxy} and
	/// {@link Ext.data.MemoryProxy}.  DataProxy implementations are usually used in conjunction with an implementation of {@link Ext.data.DataReader}
	/// (of the appropriate type which knows how to parse the data object) to provide a block of
	/// {@link Ext.data.Records} to an {@link Ext.data.Store}.  The parameter to a DataProxy constructor may be an {@link Ext.data.Connection} or can also be the
	/// config object to an {@link Ext.data.Connection}.  Custom implementations must implement either the doRequest method (preferred) or the
	/// load method (deprecated). See
	/// {@link Ext.data.HttpProxy}.{@link Ext.data.HttpProxy#doRequest doRequest} or
	/// {@link Ext.data.HttpProxy}.{@link Ext.data.HttpProxy#load load}...
	/// </summary>
	/// <htmlSummary>
	/// &lt;p&gt;Abstract base class for implementations which provide retrieval of unformatted data objects.
	/// This class is intended to be extended and should not be created directly. For existing implementations,
	/// see {@link Ext.data.DirectProxy}, {@link Ext.data.HttpProxy}, {@link Ext.data.ScriptTagProxy} and
	/// {@link Ext.data.MemoryProxy}.&lt;/p&gt;
	/// &lt;p&gt;DataProxy implementations are usually used in conjunction with an implementation of {@link Ext.data.DataReader}
	/// (of the appropriate type which knows how to parse the data object) to provide a block of
	/// {@link Ext.data.Records} to an {@link Ext.data.Store}.&lt;/p&gt;
	/// &lt;p&gt;The parameter to a DataProxy constructor may be an {@link Ext.data.Connection} or can also be the
	/// config object to an {@link Ext.data.Connection}.&lt;/p&gt;
	/// &lt;p&gt;Custom implementations must implement either the &lt;code&gt;&lt;b&gt;doRequest&lt;/b&gt;&lt;/code&gt; method (preferred) or the
	/// &lt;code&gt;load&lt;/code&gt; method (deprecated). See
	/// {@link Ext.data.HttpProxy}.{@link Ext.data.HttpProxy#doRequest doRequest} or
	/// {@link Ext.data.HttpProxy}.{@link Ext.data.HttpProxy#load load} for additional details.&lt;/p&gt;
	/// &lt;p&gt;&lt;b&gt;&lt;u&gt;Example 1&lt;/u&gt;&lt;/b&gt;&lt;/p&gt;
	/// &lt;pre&gt;&lt;code&gt;
	/// proxy: new Ext.data.ScriptTagProxy({
	/// {@link Ext.data.Connection#url url}: &apos;http://extjs.com/forum/topics-remote.php&apos;
	/// }),
	/// &lt;/code&gt;&lt;/pre&gt;
	/// &lt;p&gt;&lt;b&gt;&lt;u&gt;Example 2&lt;/u&gt;&lt;/b&gt;&lt;/p&gt;
	/// &lt;pre&gt;&lt;code&gt;
	/// proxy : new Ext.data.HttpProxy({
	/// {@link Ext.data.Connection#method method}: &apos;GET&apos;,
	/// {@link Ext.data.HttpProxy#prettyUrls prettyUrls}: false,
	/// {@link Ext.data.Connection#url url}: &apos;local/default.php&apos;, // see options parameter for {@link Ext.Ajax#request}
	/// {@link #api}: {
	/// // all actions except the following will use above url
	/// create : &apos;local/new.php&apos;,
	/// update : &apos;local/update.php&apos;
	/// }
	/// }),
	/// &lt;/code&gt;&lt;/pre&gt;
	/// &lt;p&gt;And &lt;b&gt;new in Ext version 3&lt;/b&gt;, attach centralized event-listeners upon the DataProxy class itself! This is a great place
	/// to implement a &lt;i&gt;messaging system&lt;/i&gt; to centralize your application&apos;s user-feedback and error-handling.&lt;/p&gt;
	/// &lt;pre&gt;&lt;code&gt;
	/// // Listen to all &quot;beforewrite&quot; event fired by all proxies.
	/// Ext.data.DataProxy.on(&apos;beforewrite&apos;, function(proxy, action) {
	/// console.log(&apos;beforewrite: &apos;, action);
	/// });
	///
	/// // Listen to &quot;write&quot; event fired by all proxies
	/// Ext.data.DataProxy.on(&apos;write&apos;, function(proxy, action, data, res, rs) {
	/// console.info(&apos;write: &apos;, action);
	/// });
	///
	/// // Listen to &quot;exception&quot; event fired by all proxies
	/// Ext.data.DataProxy.on(&apos;exception&apos;, function(proxy, type, action, exception) {
	/// console.error(type + action + &apos; exception);
	/// });
	/// &lt;/code&gt;&lt;/pre&gt;
	/// &lt;b&gt;Note:&lt;/b&gt; These three events are all fired with the signature of the corresponding &lt;i&gt;DataProxy instance&lt;/i&gt; event {@link #beforewrite beforewrite}, {@link #write write} and {@link #exception exception}.
	/// </htmlSummary>
	/// <definedin>src\data\DataProxy.js</definedin>
	[ScriptName("DataProxy")]
	[ScriptNamespace("Ext.data")]
	[Imported()]
	public partial class DataProxy : ext.util.Observable
	{
		
		#region Constructors
		public DataProxy(ext.data.DataProxy_Configuration config)
		{
		}
		
		/// <summary>Constructor</summary>
		public DataProxy()
		{
		}
		#endregion
		
		#region Fields
		/// <summary>
		/// Specific urls to call on CRUD action methods &quot;read&quot;, &quot;create&quot;, &quot;update&quot; and &quot;destroy&quot;.
		/// Defaults to: 
		/// api: {
		/// read : undefined,
		/// create : undefined,
		/// update : undefined,
		/// destroy : undefined
		/// }
		///  The url is built based upon the action being executed [load|create|save|destroy]
		/// using the commensurate {@link #api} property, or if undefined default to the
		/// configured {@link Ext.data.Store}.{@link Ext.data.Store#url url}.
		/// </summary>
		/// <htmlSummary>
		/// Specific urls to call on CRUD action methods &quot;read&quot;, &quot;create&quot;, &quot;update&quot; and &quot;destroy&quot;.
		/// Defaults to:&lt;pre&gt;&lt;code&gt;
		/// api: {
		/// read : undefined,
		/// create : undefined,
		/// update : undefined,
		/// destroy : undefined
		/// }
		/// &lt;/code&gt;&lt;/pre&gt;
		/// &lt;p&gt;The url is built based upon the action being executed &lt;tt&gt;[load|create|save|destroy]&lt;/tt&gt;
		/// using the commensurate &lt;tt&gt;{@link #api}&lt;/tt&gt; property, or if undefined default to the
		/// configured {@link Ext.data.Store}.{@link Ext.data.Store#url url}.&lt;/p&gt;&lt;br&gt;
		/// &lt;p&gt;For example:&lt;/p&gt;
		/// &lt;pre&gt;&lt;code&gt;
		/// api: {
		/// load : &apos;/controller/load&apos;,
		/// create : &apos;/controller/new&apos;, // Server MUST return idProperty of new record
		/// save : &apos;/controller/update&apos;,
		/// destroy : &apos;/controller/destroy_action&apos;
		/// }
		///
		/// // Alternatively, one can use the object-form to specify each API-action
		/// api: {
		/// load: {url: &apos;read.php&apos;, method: &apos;GET&apos;},
		/// create: &apos;create.php&apos;,
		/// destroy: &apos;destroy.php&apos;,
		/// save: &apos;update.php&apos;
		/// }
		/// &lt;/code&gt;&lt;/pre&gt;
		/// &lt;p&gt;If the specific URL for a given CRUD action is undefined, the CRUD action request
		/// will be directed to the configured &lt;tt&gt;{@link Ext.data.Connection#url url}&lt;/tt&gt;.&lt;/p&gt;
		/// &lt;br&gt;&lt;p&gt;&lt;b&gt;Note&lt;/b&gt;: To modify the URL for an action dynamically the appropriate API
		/// property should be modified before the action is requested using the corresponding before
		/// action event. For example to modify the URL associated with the load action:
		/// &lt;pre&gt;&lt;code&gt;
		/// // modify the url for the action
		/// myStore.on({
		/// beforeload: {
		/// fn: function (store, options) {
		/// // use &lt;tt&gt;{@link Ext.data.HttpProxy#setUrl setUrl}&lt;/tt&gt; to change the URL for *just* this request.
		/// store.proxy.setUrl(&apos;changed1.php&apos;);
		///
		/// // set optional second parameter to true to make this URL change
		/// // permanent, applying this URL for all subsequent requests.
		/// store.proxy.setUrl(&apos;changed1.php&apos;, true);
		///
		/// // Altering the proxy API should be done using the public
		/// // method &lt;tt&gt;{@link Ext.data.DataProxy#setApi setApi}&lt;/tt&gt;.
		/// store.proxy.setApi(&apos;read&apos;, &apos;changed2.php&apos;);
		///
		/// // Or set the entire API with a config-object.
		/// // When using the config-object option, you must redefine the &lt;b&gt;entire&lt;/b&gt;
		/// // API -- not just a specific action of it.
		/// store.proxy.setApi({
		/// read : &apos;changed_read.php&apos;,
		/// create : &apos;changed_create.php&apos;,
		/// update : &apos;changed_update.php&apos;,
		/// destroy : &apos;changed_destroy.php&apos;
		/// });
		/// }
		/// }
		/// });
		/// &lt;/code&gt;&lt;/pre&gt;
		/// &lt;/p&gt;
		/// </htmlSummary>
		/// <definedin>src\data\DataProxy.js</definedin>
		[ScriptName("api")]
		public object Api;
		
		/// <summary>
		/// Fires if an exception occurs in the Proxy during a remote request. This event is relayed
		/// through a corresponding {@link Ext.data.Store}.{@link Ext.data.Store#exception exception},
		/// so any Store instance may observe this event.  In addition to being fired through the DataProxy instance that raised the event, this event is also fired
		/// through the Ext.data.DataProxy class to allow for centralized processing of exception events from all
		/// DataProxies by attaching a listener to the Ext.data.DataProxy class itself.  This event can be fired for one of two reasons:    remote-request failed :  
		/// The server did not return status === 200.
		///   remote-request succeeded :  
		/// The remote-request succeeded but the reader could not read the response.
		/// This means the server returned data, but the configured Reader threw an
		/// error while reading the response. In this case, this event will be
		/// raised and the caught error will be passed along into this event.
		/// </summary>
		/// <htmlSummary>
		/// &lt;p&gt;Fires if an exception occurs in the Proxy during a remote request. This event is relayed
		/// through a corresponding {@link Ext.data.Store}.{@link Ext.data.Store#exception exception},
		/// so any Store instance may observe this event.&lt;/p&gt;
		/// &lt;p&gt;In addition to being fired through the DataProxy instance that raised the event, this event is also fired
		/// through the Ext.data.DataProxy &lt;i&gt;class&lt;/i&gt; to allow for centralized processing of exception events from &lt;b&gt;all&lt;/b&gt;
		/// DataProxies by attaching a listener to the Ext.data.DataProxy class itself.&lt;/p&gt;
		/// &lt;p&gt;This event can be fired for one of two reasons:&lt;/p&gt;
		/// &lt;div class=&quot;mdetail-params&quot;&gt;&lt;ul&gt;
		/// &lt;li&gt;remote-request &lt;b&gt;failed&lt;/b&gt; : &lt;div class=&quot;sub-desc&quot;&gt;
		/// The server did not return status === 200.
		/// &lt;/div&gt;&lt;/li&gt;
		/// &lt;li&gt;remote-request &lt;b&gt;succeeded&lt;/b&gt; : &lt;div class=&quot;sub-desc&quot;&gt;
		/// The remote-request succeeded but the reader could not read the response.
		/// This means the server returned data, but the configured Reader threw an
		/// error while reading the response. In this case, this event will be
		/// raised and the caught error will be passed along into this event.
		/// &lt;/div&gt;&lt;/li&gt;
		/// &lt;/ul&gt;&lt;/div&gt;
		/// &lt;br&gt;&lt;p&gt;This event fires with two different contexts based upon the 2nd
		/// parameter &lt;tt&gt;type [remote|response]&lt;/tt&gt;. The first four parameters
		/// are identical between the two contexts -- only the final two parameters
		/// differ.&lt;/p&gt;
		/// </htmlSummary>
		/// <definedin>src\data\DataProxy.js</definedin>
		[ScriptName("exceptionEventName")]
		public const string ExceptionEventName = "exception";
		
		/// <summary>Fires before a request to retrieve a data object.</summary>
		/// <definedin>src\data\DataProxy.js</definedin>
		[ScriptName("beforeloadEventName")]
		public const string BeforeloadEventName = "beforeload";
		
		/// <summary>Fires before the load method&apos;s callback is called.</summary>
		/// <definedin>src\data\DataProxy.js</definedin>
		[ScriptName("loadEventName")]
		public const string LoadEventName = "load";
		
		/// <summary>
		/// This event is deprecated. The signature of the loadexception event
		/// varies depending on the proxy, use the catch-all {@link #exception} event instead.
		/// This event will fire in addition to the {@link #exception} event.
		/// </summary>
		/// <htmlSummary>
		/// &lt;p&gt;This event is &lt;b&gt;deprecated&lt;/b&gt;. The signature of the loadexception event
		/// varies depending on the proxy, use the catch-all {@link #exception} event instead.
		/// This event will fire in addition to the {@link #exception} event.&lt;/p&gt;
		/// </htmlSummary>
		/// <definedin>src\data\DataProxy.js</definedin>
		/// <deprecated>Deprecated</deprecated>
		[ScriptName("loadexceptionEventName")]
		public const string LoadexceptionEventName = "loadexception";
		
		/// <summary>
		/// Fires before a request is generated for one of the actions Ext.data.Api.actions.create|update|destroy  In addition to being fired through the DataProxy instance that raised the event, this event is also fired
		/// through the Ext.data.DataProxy class to allow for centralized processing of beforewrite events from all
		/// DataProxies by attaching a listener to the Ext.data.DataProxy class itself.
		/// </summary>
		/// <htmlSummary>
		/// &lt;p&gt;Fires before a request is generated for one of the actions Ext.data.Api.actions.create|update|destroy&lt;/p&gt;
		/// &lt;p&gt;In addition to being fired through the DataProxy instance that raised the event, this event is also fired
		/// through the Ext.data.DataProxy &lt;i&gt;class&lt;/i&gt; to allow for centralized processing of beforewrite events from &lt;b&gt;all&lt;/b&gt;
		/// DataProxies by attaching a listener to the Ext.data.DataProxy class itself.&lt;/p&gt;
		/// </htmlSummary>
		/// <definedin>src\data\DataProxy.js</definedin>
		[ScriptName("beforewriteEventName")]
		public const string BeforewriteEventName = "beforewrite";
		
		/// <summary>
		/// Fires before the request-callback is called  In addition to being fired through the DataProxy instance that raised the event, this event is also fired
		/// through the Ext.data.DataProxy class to allow for centralized processing of write events from all
		/// DataProxies by attaching a listener to the Ext.data.DataProxy class itself.
		/// </summary>
		/// <htmlSummary>
		/// &lt;p&gt;Fires before the request-callback is called&lt;/p&gt;
		/// &lt;p&gt;In addition to being fired through the DataProxy instance that raised the event, this event is also fired
		/// through the Ext.data.DataProxy &lt;i&gt;class&lt;/i&gt; to allow for centralized processing of write events from &lt;b&gt;all&lt;/b&gt;
		/// DataProxies by attaching a listener to the Ext.data.DataProxy class itself.&lt;/p&gt;
		/// </htmlSummary>
		/// <definedin>src\data\DataProxy.js</definedin>
		[ScriptName("writeEventName")]
		public const string WriteEventName = "write";
		
		/// <summary>Defaults to false. Set to true to operate in a RESTful manner.</summary>
		/// <htmlSummary>
		/// &lt;p&gt;Defaults to &lt;tt&gt;false&lt;/tt&gt;. Set to &lt;tt&gt;true&lt;/tt&gt; to operate in a RESTful manner.&lt;/p&gt;
		/// &lt;br&gt;&lt;p&gt; Note: this parameter will automatically be set to &lt;tt&gt;true&lt;/tt&gt; if the
		/// {@link Ext.data.Store} it is plugged into is set to &lt;code&gt;restful: true&lt;/code&gt;. If the
		/// Store is RESTful, there is no need to set this option on the proxy.&lt;/p&gt;
		/// &lt;br&gt;&lt;p&gt;RESTful implementations enable the serverside framework to automatically route
		/// actions sent to one url based upon the HTTP method, for example:
		/// &lt;pre&gt;&lt;code&gt;
		/// store: new Ext.data.Store({
		/// restful: true,
		/// proxy: new Ext.data.HttpProxy({url:&apos;/users&apos;}); // all requests sent to /users
		/// ...
		/// )}
		/// &lt;/code&gt;&lt;/pre&gt;
		/// If there is no &lt;code&gt;{@link #api}&lt;/code&gt; specified in the configuration of the proxy,
		/// all requests will be marshalled to a single RESTful url (/users) so the serverside
		/// framework can inspect the HTTP Method and act accordingly:
		/// &lt;pre&gt;
		/// &lt;u&gt;Method&lt;/u&gt; &lt;u&gt;url&lt;/u&gt; &lt;u&gt;action&lt;/u&gt;
		/// POST /users create
		/// GET /users read
		/// PUT /users/23 update
		/// DESTROY /users/23 delete
		/// &lt;/pre&gt;&lt;/p&gt;
		/// &lt;p&gt;If set to &lt;tt&gt;true&lt;/tt&gt;, a {@link Ext.data.Record#phantom non-phantom} record&apos;s
		/// {@link Ext.data.Record#id id} will be appended to the url. Some MVC (e.g., Ruby on Rails,
		/// Merb and Django) support segment based urls where the segments in the URL follow the
		/// Model-View-Controller approach:&lt;pre&gt;&lt;code&gt;
		/// someSite.com/controller/action/id
		/// &lt;/code&gt;&lt;/pre&gt;
		/// Where the segments in the url are typically:&lt;div class=&quot;mdetail-params&quot;&gt;&lt;ul&gt;
		/// &lt;li&gt;The first segment : represents the controller class that should be invoked.&lt;/li&gt;
		/// &lt;li&gt;The second segment : represents the class function, or method, that should be called.&lt;/li&gt;
		/// &lt;li&gt;The third segment : represents the ID (a variable typically passed to the method).&lt;/li&gt;
		/// &lt;/ul&gt;&lt;/div&gt;&lt;/p&gt;
		/// &lt;br&gt;&lt;p&gt;Refer to &lt;code&gt;{@link Ext.data.DataProxy#api}&lt;/code&gt; for additional information.&lt;/p&gt;
		/// </htmlSummary>
		/// <definedin>src\data\DataProxy.js</definedin>
		[ScriptName("restful")]
		public bool Restful;
		
		/// <summary>
		/// Abstract method that should be implemented in all subclasses. Note: Should only be used by custom-proxy developers.
		/// (e.g.: {@link Ext.data.HttpProxy#doRequest HttpProxy.doRequest},
		/// {@link Ext.data.DirectProxy#doRequest DirectProxy.doRequest}).
		/// </summary>
		/// <htmlSummary>
		/// Abstract method that should be implemented in all subclasses. &lt;b&gt;Note:&lt;/b&gt; Should only be used by custom-proxy developers.
		/// (e.g.: {@link Ext.data.HttpProxy#doRequest HttpProxy.doRequest},
		/// {@link Ext.data.DirectProxy#doRequest DirectProxy.doRequest}).
		/// </htmlSummary>
		/// <definedin>src\data\DataProxy.js</definedin>
		[ScriptName("doRequest")]
		public System.Delegate DoRequest;
		
		/// <summary>Abstract method that should be implemented in all subclasses. Note: Should only be used by custom-proxy developers. Callback for read {@link Ext.data.Api#actions action}.</summary>
		/// <htmlSummary>Abstract method that should be implemented in all subclasses. &lt;b&gt;Note:&lt;/b&gt; Should only be used by custom-proxy developers. Callback for read {@link Ext.data.Api#actions action}.</htmlSummary>
		/// <definedin>src\data\DataProxy.js</definedin>
		[ScriptName("onRead")]
		public System.Delegate OnRead;
		
		/// <summary>Abstract method that should be implemented in all subclasses. Note: Should only be used by custom-proxy developers. Callback for create, update and destroy {@link Ext.data.Api#actions actions}.</summary>
		/// <htmlSummary>Abstract method that should be implemented in all subclasses. &lt;b&gt;Note:&lt;/b&gt; Should only be used by custom-proxy developers. Callback for &lt;i&gt;create, update and destroy&lt;/i&gt; {@link Ext.data.Api#actions actions}.</htmlSummary>
		/// <definedin>src\data\DataProxy.js</definedin>
		[ScriptName("onWrite")]
		public System.Delegate OnWrite;
		#endregion
		
		#region Methods
		/// <summary>
		/// Returns true if the specified action is defined as a unique action in the api-config.
		/// request. If all API-actions are routed to unique urls, the xaction parameter is unecessary. However, if no api is defined
		/// and all Proxy actions are routed to DataProxy#url, the server-side will require the xaction parameter to perform a switch to
		/// the corresponding code for CRUD action.
		/// </summary>
		/// <definedin>src\data\DataProxy.js</definedin>
		/// <param name="action">Ext.data.Api.CREATE|READ|UPDATE|DESTROY</param>
		[ScriptName("isApiAction")]
		public bool IsApiAction(string action)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Deprecated load method using old method signature. See {@doRequest} for preferred method.</summary>
		/// <htmlSummary>&lt;b&gt;Deprecated&lt;/b&gt; load method using old method signature. See {@doRequest} for preferred method.</htmlSummary>
		/// <definedin>src\data\DataProxy.js</definedin>
		/// <deprecated>Deprecated</deprecated>
		/// <param name="params"></param>
		/// <param name="reader"></param>
		/// <param name="callback"></param>
		/// <param name="scope"></param>
		/// <param name="arg"></param>
		[ScriptName("load")]
		public void LoadMethod(object @params, object reader, object callback, object scope, object arg)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Destroys the proxy by purging any event listeners and cancelling any active requests.</summary>
		/// <definedin>src\data\DataProxy.js</definedin>
		[ScriptName("destroy")]
		public void Destroy()
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Redefines the Proxy&apos;s API or a single action of an API. Can be called with two method signatures.  If called with an object as the only parameter, the object should redefine the entire API, e.g.:  
		/// proxy.setApi({
		/// read : &apos;/users/read&apos;,
		/// create : &apos;/users/create&apos;,
		/// update : &apos;/users/update&apos;,
		/// destroy : &apos;/users/destroy&apos;
		/// });
		///  If called with two parameters, the first parameter should be a string specifying the API action to
		/// redefine and the second parameter should be the URL (or function if using DirectProxy) to call for that action, e.g.:  
		/// proxy.setApi(Ext.data.Api.actions.read, &apos;/users/new_load_url&apos;);
		/// </summary>
		/// <htmlSummary>
		/// &lt;p&gt;Redefines the Proxy&apos;s API or a single action of an API. Can be called with two method signatures.&lt;/p&gt;
		/// &lt;p&gt;If called with an object as the only parameter, the object should redefine the &lt;b&gt;entire&lt;/b&gt; API, e.g.:&lt;/p&gt;&lt;pre&gt;&lt;code&gt;
		/// proxy.setApi({
		/// read : &apos;/users/read&apos;,
		/// create : &apos;/users/create&apos;,
		/// update : &apos;/users/update&apos;,
		/// destroy : &apos;/users/destroy&apos;
		/// });
		/// &lt;/code&gt;&lt;/pre&gt;
		/// &lt;p&gt;If called with two parameters, the first parameter should be a string specifying the API action to
		/// redefine and the second parameter should be the URL (or function if using DirectProxy) to call for that action, e.g.:&lt;/p&gt;&lt;pre&gt;&lt;code&gt;
		/// proxy.setApi(Ext.data.Api.actions.read, &apos;/users/new_load_url&apos;);
		/// &lt;/code&gt;&lt;/pre&gt;
		/// </htmlSummary>
		/// <definedin>src\data\DataProxy.js</definedin>
		/// <param name="api">An API specification object, or the name of an action.</param>
		/// <param name="url">The URL (or function if using DirectProxy) to call for the action.</param>
		[ScriptName("setApi")]
		public void SetApi(string api, string url)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Redefines the Proxy&apos;s API or a single action of an API. Can be called with two method signatures.  If called with an object as the only parameter, the object should redefine the entire API, e.g.:  
		/// proxy.setApi({
		/// read : &apos;/users/read&apos;,
		/// create : &apos;/users/create&apos;,
		/// update : &apos;/users/update&apos;,
		/// destroy : &apos;/users/destroy&apos;
		/// });
		///  If called with two parameters, the first parameter should be a string specifying the API action to
		/// redefine and the second parameter should be the URL (or function if using DirectProxy) to call for that action, e.g.:  
		/// proxy.setApi(Ext.data.Api.actions.read, &apos;/users/new_load_url&apos;);
		/// </summary>
		/// <htmlSummary>
		/// &lt;p&gt;Redefines the Proxy&apos;s API or a single action of an API. Can be called with two method signatures.&lt;/p&gt;
		/// &lt;p&gt;If called with an object as the only parameter, the object should redefine the &lt;b&gt;entire&lt;/b&gt; API, e.g.:&lt;/p&gt;&lt;pre&gt;&lt;code&gt;
		/// proxy.setApi({
		/// read : &apos;/users/read&apos;,
		/// create : &apos;/users/create&apos;,
		/// update : &apos;/users/update&apos;,
		/// destroy : &apos;/users/destroy&apos;
		/// });
		/// &lt;/code&gt;&lt;/pre&gt;
		/// &lt;p&gt;If called with two parameters, the first parameter should be a string specifying the API action to
		/// redefine and the second parameter should be the URL (or function if using DirectProxy) to call for that action, e.g.:&lt;/p&gt;&lt;pre&gt;&lt;code&gt;
		/// proxy.setApi(Ext.data.Api.actions.read, &apos;/users/new_load_url&apos;);
		/// &lt;/code&gt;&lt;/pre&gt;
		/// </htmlSummary>
		/// <definedin>src\data\DataProxy.js</definedin>
		/// <param name="api">An API specification object, or the name of an action.</param>
		/// <param name="url">The URL (or function if using DirectProxy) to call for the action.</param>
		[ScriptName("setApi")]
		public void SetApi(string api, System.Delegate url)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Redefines the Proxy&apos;s API or a single action of an API. Can be called with two method signatures.  If called with an object as the only parameter, the object should redefine the entire API, e.g.:  
		/// proxy.setApi({
		/// read : &apos;/users/read&apos;,
		/// create : &apos;/users/create&apos;,
		/// update : &apos;/users/update&apos;,
		/// destroy : &apos;/users/destroy&apos;
		/// });
		///  If called with two parameters, the first parameter should be a string specifying the API action to
		/// redefine and the second parameter should be the URL (or function if using DirectProxy) to call for that action, e.g.:  
		/// proxy.setApi(Ext.data.Api.actions.read, &apos;/users/new_load_url&apos;);
		/// </summary>
		/// <htmlSummary>
		/// &lt;p&gt;Redefines the Proxy&apos;s API or a single action of an API. Can be called with two method signatures.&lt;/p&gt;
		/// &lt;p&gt;If called with an object as the only parameter, the object should redefine the &lt;b&gt;entire&lt;/b&gt; API, e.g.:&lt;/p&gt;&lt;pre&gt;&lt;code&gt;
		/// proxy.setApi({
		/// read : &apos;/users/read&apos;,
		/// create : &apos;/users/create&apos;,
		/// update : &apos;/users/update&apos;,
		/// destroy : &apos;/users/destroy&apos;
		/// });
		/// &lt;/code&gt;&lt;/pre&gt;
		/// &lt;p&gt;If called with two parameters, the first parameter should be a string specifying the API action to
		/// redefine and the second parameter should be the URL (or function if using DirectProxy) to call for that action, e.g.:&lt;/p&gt;&lt;pre&gt;&lt;code&gt;
		/// proxy.setApi(Ext.data.Api.actions.read, &apos;/users/new_load_url&apos;);
		/// &lt;/code&gt;&lt;/pre&gt;
		/// </htmlSummary>
		/// <definedin>src\data\DataProxy.js</definedin>
		/// <param name="api">An API specification object, or the name of an action.</param>
		/// <param name="url">The URL (or function if using DirectProxy) to call for the action.</param>
		[ScriptName("setApi")]
		public void SetApi(object api, string url)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Redefines the Proxy&apos;s API or a single action of an API. Can be called with two method signatures.  If called with an object as the only parameter, the object should redefine the entire API, e.g.:  
		/// proxy.setApi({
		/// read : &apos;/users/read&apos;,
		/// create : &apos;/users/create&apos;,
		/// update : &apos;/users/update&apos;,
		/// destroy : &apos;/users/destroy&apos;
		/// });
		///  If called with two parameters, the first parameter should be a string specifying the API action to
		/// redefine and the second parameter should be the URL (or function if using DirectProxy) to call for that action, e.g.:  
		/// proxy.setApi(Ext.data.Api.actions.read, &apos;/users/new_load_url&apos;);
		/// </summary>
		/// <htmlSummary>
		/// &lt;p&gt;Redefines the Proxy&apos;s API or a single action of an API. Can be called with two method signatures.&lt;/p&gt;
		/// &lt;p&gt;If called with an object as the only parameter, the object should redefine the &lt;b&gt;entire&lt;/b&gt; API, e.g.:&lt;/p&gt;&lt;pre&gt;&lt;code&gt;
		/// proxy.setApi({
		/// read : &apos;/users/read&apos;,
		/// create : &apos;/users/create&apos;,
		/// update : &apos;/users/update&apos;,
		/// destroy : &apos;/users/destroy&apos;
		/// });
		/// &lt;/code&gt;&lt;/pre&gt;
		/// &lt;p&gt;If called with two parameters, the first parameter should be a string specifying the API action to
		/// redefine and the second parameter should be the URL (or function if using DirectProxy) to call for that action, e.g.:&lt;/p&gt;&lt;pre&gt;&lt;code&gt;
		/// proxy.setApi(Ext.data.Api.actions.read, &apos;/users/new_load_url&apos;);
		/// &lt;/code&gt;&lt;/pre&gt;
		/// </htmlSummary>
		/// <definedin>src\data\DataProxy.js</definedin>
		/// <param name="api">An API specification object, or the name of an action.</param>
		/// <param name="url">The URL (or function if using DirectProxy) to call for the action.</param>
		[ScriptName("setApi")]
		public void SetApi(object api, System.Delegate url)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>All proxy actions are executed through this method. Automatically fires the &quot;before&quot; + action event</summary>
		/// <definedin>src\data\DataProxy.js</definedin>
		/// <param name="action">Name of the action</param>
		/// <param name="rs">Will be null when action is &apos;load&apos;</param>
		/// <param name="params"></param>
		/// <param name="reader"></param>
		/// <param name="callback"></param>
		/// <param name="scope">The scope (<c>this</c> reference) in which the callback function is executed. Defaults to the Proxy object.</param>
		/// <param name="options">Any options specified for the action (e.g. see {@link Ext.data.Store#load}.</param>
		[ScriptName("request")]
		public void Request(string action, ext.data.RecordClass rs, object @params, ext.data.DataReader reader, System.Delegate callback, object scope, object options)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>All proxy actions are executed through this method. Automatically fires the &quot;before&quot; + action event</summary>
		/// <definedin>src\data\DataProxy.js</definedin>
		/// <param name="action">Name of the action</param>
		/// <param name="rs">Will be null when action is &apos;load&apos;</param>
		/// <param name="params"></param>
		/// <param name="reader"></param>
		/// <param name="callback"></param>
		/// <param name="scope">The scope (<c>this</c> reference) in which the callback function is executed. Defaults to the Proxy object.</param>
		/// <param name="options">Any options specified for the action (e.g. see {@link Ext.data.Store#load}.</param>
		[ScriptName("request")]
		public void Request(string action, ext.data.RecordClass[] rs, object @params, ext.data.DataReader reader, System.Delegate callback, object scope, object options)
		{
			throw new System.Exception("Imported - not implemented");
		}
		#endregion
		
		#region Events
		/// <summary>
		/// Fires if an exception occurs in the Proxy during a remote request. This event is relayed
		/// through a corresponding {@link Ext.data.Store}.{@link Ext.data.Store#exception exception},
		/// so any Store instance may observe this event.  In addition to being fired through the DataProxy instance that raised the event, this event is also fired
		/// through the Ext.data.DataProxy class to allow for centralized processing of exception events from all
		/// DataProxies by attaching a listener to the Ext.data.DataProxy class itself.  This event can be fired for one of two reasons:    remote-request failed :  
		/// The server did not return status === 200.
		///   remote-request succeeded :  
		/// The remote-request succeeded but the reader could not read the response.
		/// This means the server returned data, but the configured Reader threw an
		/// error while reading the response. In this case, this event will be
		/// raised and the caught error will be passed along into this event.
		/// </summary>
		/// <htmlSummary>
		/// &lt;p&gt;Fires if an exception occurs in the Proxy during a remote request. This event is relayed
		/// through a corresponding {@link Ext.data.Store}.{@link Ext.data.Store#exception exception},
		/// so any Store instance may observe this event.&lt;/p&gt;
		/// &lt;p&gt;In addition to being fired through the DataProxy instance that raised the event, this event is also fired
		/// through the Ext.data.DataProxy &lt;i&gt;class&lt;/i&gt; to allow for centralized processing of exception events from &lt;b&gt;all&lt;/b&gt;
		/// DataProxies by attaching a listener to the Ext.data.DataProxy class itself.&lt;/p&gt;
		/// &lt;p&gt;This event can be fired for one of two reasons:&lt;/p&gt;
		/// &lt;div class=&quot;mdetail-params&quot;&gt;&lt;ul&gt;
		/// &lt;li&gt;remote-request &lt;b&gt;failed&lt;/b&gt; : &lt;div class=&quot;sub-desc&quot;&gt;
		/// The server did not return status === 200.
		/// &lt;/div&gt;&lt;/li&gt;
		/// &lt;li&gt;remote-request &lt;b&gt;succeeded&lt;/b&gt; : &lt;div class=&quot;sub-desc&quot;&gt;
		/// The remote-request succeeded but the reader could not read the response.
		/// This means the server returned data, but the configured Reader threw an
		/// error while reading the response. In this case, this event will be
		/// raised and the caught error will be passed along into this event.
		/// &lt;/div&gt;&lt;/li&gt;
		/// &lt;/ul&gt;&lt;/div&gt;
		/// &lt;br&gt;&lt;p&gt;This event fires with two different contexts based upon the 2nd
		/// parameter &lt;tt&gt;type [remote|response]&lt;/tt&gt;. The first four parameters
		/// are identical between the two contexts -- only the final two parameters
		/// differ.&lt;/p&gt;
		/// </htmlSummary>
		/// <definedin>src\data\DataProxy.js</definedin>
		[ScriptName("exception")]
		public event ext.auto.Delegate_ext_data_DataProxy_And_System_String_And_System_String_And_System_Object_And_System_Object_And_System_Object Exception;
		
		/// <summary>Fires before a request to retrieve a data object.</summary>
		/// <definedin>src\data\DataProxy.js</definedin>
		[ScriptName("beforeload")]
		public event ext.auto.Delegate_ext_data_DataProxy_And_System_Object Beforeload;
		
		/// <summary>Fires before the load method&apos;s callback is called.</summary>
		/// <definedin>src\data\DataProxy.js</definedin>
		[ScriptName("load")]
		public event ext.auto.Delegate_ext_data_DataProxy_And_System_Object_And_System_Object Load;
		
		/// <summary>
		/// This event is deprecated. The signature of the loadexception event
		/// varies depending on the proxy, use the catch-all {@link #exception} event instead.
		/// This event will fire in addition to the {@link #exception} event.
		/// </summary>
		/// <htmlSummary>
		/// &lt;p&gt;This event is &lt;b&gt;deprecated&lt;/b&gt;. The signature of the loadexception event
		/// varies depending on the proxy, use the catch-all {@link #exception} event instead.
		/// This event will fire in addition to the {@link #exception} event.&lt;/p&gt;
		/// </htmlSummary>
		/// <definedin>src\data\DataProxy.js</definedin>
		/// <deprecated>Deprecated</deprecated>
		[ScriptName("loadexception")]
		public event ext.auto.Delegate_System_Object Loadexception;
		
		/// <summary>
		/// Fires before a request is generated for one of the actions Ext.data.Api.actions.create|update|destroy  In addition to being fired through the DataProxy instance that raised the event, this event is also fired
		/// through the Ext.data.DataProxy class to allow for centralized processing of beforewrite events from all
		/// DataProxies by attaching a listener to the Ext.data.DataProxy class itself.
		/// </summary>
		/// <htmlSummary>
		/// &lt;p&gt;Fires before a request is generated for one of the actions Ext.data.Api.actions.create|update|destroy&lt;/p&gt;
		/// &lt;p&gt;In addition to being fired through the DataProxy instance that raised the event, this event is also fired
		/// through the Ext.data.DataProxy &lt;i&gt;class&lt;/i&gt; to allow for centralized processing of beforewrite events from &lt;b&gt;all&lt;/b&gt;
		/// DataProxies by attaching a listener to the Ext.data.DataProxy class itself.&lt;/p&gt;
		/// </htmlSummary>
		/// <definedin>src\data\DataProxy.js</definedin>
		[ScriptName("beforewrite")]
		public event ext.auto.Delegate_ext_data_DataProxy_And_System_String_And_ext_auto_ext_data_RecordClass_Or_ext_data_RecordClassArray_And_System_Object Beforewrite;
		
		/// <summary>
		/// Fires before the request-callback is called  In addition to being fired through the DataProxy instance that raised the event, this event is also fired
		/// through the Ext.data.DataProxy class to allow for centralized processing of write events from all
		/// DataProxies by attaching a listener to the Ext.data.DataProxy class itself.
		/// </summary>
		/// <htmlSummary>
		/// &lt;p&gt;Fires before the request-callback is called&lt;/p&gt;
		/// &lt;p&gt;In addition to being fired through the DataProxy instance that raised the event, this event is also fired
		/// through the Ext.data.DataProxy &lt;i&gt;class&lt;/i&gt; to allow for centralized processing of write events from &lt;b&gt;all&lt;/b&gt;
		/// DataProxies by attaching a listener to the Ext.data.DataProxy class itself.&lt;/p&gt;
		/// </htmlSummary>
		/// <definedin>src\data\DataProxy.js</definedin>
		[ScriptName("write")]
		public event ext.auto.Delegate_ext_data_DataProxy_And_System_String_And_System_Object_And_System_Object_And_ext_auto_ext_data_RecordClass_Or_ext_data_RecordClassArray_And_System_Object Write;
		#endregion
	}
}
